{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ensembles\n",
    "<h3> План семинара </h3>\n",
    "\n",
    "* **Bagging** \n",
    " - Bootstrap\n",
    " - Как построить доверительный интревал с помощью bootstrap\n",
    " - Описание композиции Bagging\n",
    " - Bagging в применении в DT\n",
    "\n",
    "* **Bias-vairance trade-off**\n",
    "  - Разложение ошибки на Bias и Variance\n",
    "  - bias\\variance для bagging и boosting\n",
    "    \n",
    "* **Random Forest** \n",
    " - Алгоритм построения случайного леса\n",
    " - Применение RandomForest на реальной задаче (предсказание оттока клиентов)\n",
    " - Out-of-bag error\n",
    " \n",
    "* **Основные выводы** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "plt.rcParams['figure.figsize'] = 10, 6\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.datasets import load_digits as load\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier, BaggingRegressor\n",
    "from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import cross_val_score, StratifiedKFold, GridSearchCV\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------\n",
    "<h1 align=\"center\">Bagging</h1> \n",
    "\n",
    "** Вопросы для самоконтроля**\n",
    "* Зачем нужно строить композиции над алгоритмами?\n",
    "* Что такое bootstrap-выборка?\n",
    "* Что такие RSM, Pasting?\n",
    "* Какие бывают варианты построения композиций N базовых алгоритмов классификации?\n",
    "* Что такое Bagging?\n",
    "* Почему работает Bagging?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bootstrap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='img/bootstrap.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Важно! **\n",
    "    - Бутстрепная выборка имеет такой же размер, что и исходная\n",
    "    - Генерация с повторениями"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bagging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $$a_{Bagging}(x) = \\frac{1}{M}\\sum_{i=1}^M a_i(x)$$\n",
    "\n",
    "$a_i(x)$ - обучен на бутстреп-выборке $X^i$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='img/bagging.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = load()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "f = X.shape[1]\n",
    "\n",
    "rnd_d3 = DecisionTreeClassifier(max_features=int(f ** 0.5)) # Решающее дерево с рандомизацией в сплитах\n",
    "d3 = DecisionTreeClassifier() # Обычное решающее дерево"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RandomForestClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Качество классификации одним решающим деревом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision tree: 0.7690972327560335\n"
     ]
    }
   ],
   "source": [
    "print(\"Decision tree:\", cross_val_score(d3, X, y).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Качество бэггинга над решающими деревьями:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bagging: 0.8870792747165835\n"
     ]
    }
   ],
   "source": [
    "print(\"Bagging:\", cross_val_score(BaggingClassifier(d3), X, y).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Какой недостаток есть у деревьев?\n",
    "- Как bagging борется с этим недостатком?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Как можно улучшить качество? При построении каждого узла отбирать случайные max_features признаков и искать информативное разбиение только по одному из них."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Randomized Bagging: 0.903178513945757\n"
     ]
    }
   ],
   "source": [
    "print(\"Randomized Bagging:\", cross_val_score(BaggingClassifier(rnd_d3), X, y).mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Bias-Variance Tradeoff</h1> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Разложение ошибки на Bias и Variance\n",
    "\n",
    "#### Какая природа бывает у ошибок\n",
    "\n",
    "<img src='img/bv_darts.png' width=400>\n",
    "\n",
    "#### Как это отражается на модели\n",
    "\n",
    "<img src='img/bv_model_complex.png'>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bias-Variance tradeoff (напоминание)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$y = f(x) + \\varepsilon$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\varepsilon \\sim N(0, \\sigma^2)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$y \\sim N(f(x), \\sigma^2)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='img/bv_1.png'>\n",
    "<img src='img/bv_2.png'>\n",
    "<img src='img/bv_3.png'>\n",
    "<img src='img/bv_4.png'>\n",
    "<img src='img/bv_5.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bias\\variance для Bagging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотрим задачу регрессии с базовыми алгоритмами $b_1(x), .. ,b_n(x)$. Предположим, что существует истинная функция ответа для всех объектов $y(x)$, а также задано распределение на объектах $p(x)$. В этом случае мы можем записать ошибку каждой функции регрессии:\n",
    "\n",
    "$$\\varepsilon_i(x) = b_i(x) - y(x), i=1,..,n$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Средняя ошибка построенных функций регрессии имеет вид:\n",
    "    $$E_1 = \\dfrac{1}{n} E_x \\varepsilon_i^2(x)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Предположим, что ошибки несмещены и некоррелированы:\n",
    "    $$E_x \\varepsilon_i(x) = 0$$\n",
    "    $$E_x \\varepsilon_i(x) \\varepsilon_j(x) = 0, i \\neq j$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Построим теперь новую функцию регрессии, которая будет усреднять ответы построенных нами функций:\n",
    "    $$a(x) = \\dfrac{1}{n} \\sum_{i=1}^n b_i(x)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Найдем ее среднеквадратичную ошибку:\n",
    "<img src=\"img/bv_6.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='img/forest.jpeg' width=700>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Алгоритм построения случайного леса из $N$ деревьев"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для каждого $n = 1..N$:\n",
    "\n",
    "Сгенерировать выборку $X_n$ с помощью бутстрэпа;\n",
    "Построить решающее дерево $b_n$ по выборке $X_n$:\n",
    "* по заданному критерию мы выбираем лучший признак, делаем разбиение в дереве по нему и так до исчерпания выборки\n",
    "* дерево строится, пока в каждом листе не более $n_{min}$ объектов или пока не достигнем определенной высоты дерева\n",
    "* при каждом разбиении сначала выбирается $m$ случайных признаков из $n$ исходных, и оптимальное разделение выборки ищется только среди них."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итоговый классификатор:\n",
    "    $$ a(x) = \\dfrac{1}{N} \\sum_{i=1}^{N} b_i(x)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$m$ советуют выбирать равным:\n",
    "- $\\sqrt{n}$ для классификации\n",
    "- $\\dfrac{n}{3}$ для регрессии"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest из sklearn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полный список параметров случайного леса для задачи регрессии:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nclass sklearn.ensemble.RandomForestRegressor(\\n    n_estimators — число деревьев в \"лесу\" (по дефолту – 10)\\n    criterion — функция, которая измеряет качество разбиения ветки дерева (по дефолту — \"mse\" , так же можно выбрать \"mae\")\\n    max_features — число признаков, по которым ищется разбиение. Вы можете указать конкретное число или процент признаков, либо выбрать из доступных значений: \"auto\" (все признаки), \"sqrt\", \"log2\". По дефолту стоит \"auto\".\\n    max_depth — максимальная глубина дерева  (по дефолту глубина не ограничена)\\n    min_samples_split — минимальное количество объектов, необходимое для разделения внутреннего узла. Можно задать числом или процентом от общего числа объектов (по дефолту — 2)\\n    min_samples_leaf — минимальное число объектов в листе. Можно задать числом или процентом от общего числа объектов (по дефолту — 1)\\n    min_weight_fraction_leaf — минимальная взвешенная доля от общей суммы весов (всех входных объектов) должна быть в листе (по дефолту имеют одинаковый вес)\\n    max_leaf_nodes — максимальное количество листьев (по дефолту нет ограничения)\\n    min_impurity_split — порог для остановки наращивания дерева (по дефолту 1е-7)\\n    bootstrap — применять ли бустрэп для построения дерева (по дефолту True)\\n    oob_score — использовать ли out-of-bag объекты для оценки R^2 (по дефолту False)\\n    n_jobs — количество ядер для построения модели и предсказаний (по дефолту 1, если поставить -1, то будут использоваться все ядра)\\n    random_state — начальное значение для генерации случайных чисел (по дефолту его нет, если хотите воспроизводимые результаты, то нужно указать любое число типа int\\n    verbose — вывод логов по построению деревьев (по дефолту 0)\\n    warm_start — использует уже натренированую модель и добавляет деревьев в ансамбль (по дефолту False)\\n)\\n'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "class sklearn.ensemble.RandomForestRegressor(\n",
    "    n_estimators — число деревьев в \"лесу\" (по дефолту – 10)\n",
    "    criterion — функция, которая измеряет качество разбиения ветки дерева (по дефолту — \"mse\" , так же можно выбрать \"mae\")\n",
    "    max_features — число признаков, по которым ищется разбиение. Вы можете указать конкретное число или процент признаков, либо выбрать из доступных значений: \"auto\" (все признаки), \"sqrt\", \"log2\". По дефолту стоит \"auto\".\n",
    "    max_depth — максимальная глубина дерева  (по дефолту глубина не ограничена)\n",
    "    min_samples_split — минимальное количество объектов, необходимое для разделения внутреннего узла. Можно задать числом или процентом от общего числа объектов (по дефолту — 2)\n",
    "    min_samples_leaf — минимальное число объектов в листе. Можно задать числом или процентом от общего числа объектов (по дефолту — 1)\n",
    "    min_weight_fraction_leaf — минимальная взвешенная доля от общей суммы весов (всех входных объектов) должна быть в листе (по дефолту имеют одинаковый вес)\n",
    "    max_leaf_nodes — максимальное количество листьев (по дефолту нет ограничения)\n",
    "    min_impurity_split — порог для остановки наращивания дерева (по дефолту 1е-7)\n",
    "    bootstrap — применять ли бустрэп для построения дерева (по дефолту True)\n",
    "    oob_score — использовать ли out-of-bag объекты для оценки R^2 (по дефолту False)\n",
    "    n_jobs — количество ядер для построения модели и предсказаний (по дефолту 1, если поставить -1, то будут использоваться все ядра)\n",
    "    random_state — начальное значение для генерации случайных чисел (по дефолту его нет, если хотите воспроизводимые результаты, то нужно указать любое число типа int\n",
    "    verbose — вывод логов по построению деревьев (по дефолту 0)\n",
    "    warm_start — использует уже натренированую модель и добавляет деревьев в ансамбль (по дефолту False)\n",
    ")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для задачи классификации все почти то же самое, мы приведем только те параметры, которыми RandomForestClassifier отличается от RandomForestRegressor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nclass sklearn.ensemble.RandomForestClassifier(\\n    criterion — поскольку у нас теперь задача классификации, то по дефолту выбран критерий \"gini\" (можно выбрать \"entropy\")\\n    class_weight — вес каждого класса (по дефолту все веса равны 1, но можно передать словарь с весами, либо явно указать \"balanced\", тогда веса классов будут равны их исходным частям в генеральной совокупности; также можно указать \"balanced_subsample\", тогда веса на каждой подвыборке будут меняться в зависимости от распределения классов на этой подвыборке.\\n)\\n'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "class sklearn.ensemble.RandomForestClassifier(\n",
    "    criterion — поскольку у нас теперь задача классификации, то по дефолту выбран критерий \"gini\" (можно выбрать \"entropy\")\n",
    "    class_weight — вес каждого класса (по дефолту все веса равны 1, но можно передать словарь с весами, либо явно указать \"balanced\", тогда веса классов будут равны их исходным частям в генеральной совокупности; также можно указать \"balanced_subsample\", тогда веса на каждой подвыборке будут меняться в зависимости от распределения классов на этой подвыборке.\n",
    ")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "При построениии модели в первую очередь стоит обратить внимание на следующие параметры:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- n_estimators — число деревьев в \"лесу\"\n",
    "- criterion — критерий для разбиения выборки в вершине\n",
    "- max_features — число признаков, по которым ищется разбиение\n",
    "- min_samples_leaf — минимальное число объектов в листе\n",
    "- max_depth — максимальная глубина дерева\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Применение RandomForest на реальной задаче (предсказание оттока клиентов)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данные можно взять тут: https://github.com/Yorko/mlcourse_open/blob/master/data/telecom_churn.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2020-03-15 19:38:34--  https://raw.githubusercontent.com/Yorko/mlcourse.ai/master/data/telecom_churn.csv\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.112.133\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.112.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 279997 (273K) [text/plain]\n",
      "Saving to: ‘telecom_churn.csv’\n",
      "\n",
      "telecom_churn.csv   100%[===================>] 273.43K  1.46MB/s    in 0.2s    \n",
      "\n",
      "2020-03-15 19:38:34 (1.46 MB/s) - ‘telecom_churn.csv’ saved [279997/279997]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget https://raw.githubusercontent.com/Yorko/mlcourse.ai/master/data/telecom_churn.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV accuracy score: 91.48%\n"
     ]
    }
   ],
   "source": [
    "# Загружаем данные\n",
    "df = pd.read_csv(\"telecom_churn.csv\")\n",
    "\n",
    "# Выбираем сначала только колонки с числовым типом данных\n",
    "cols = []\n",
    "for i in df.columns:\n",
    "    if (df[i].dtype == \"float64\") or (df[i].dtype == 'int64'):\n",
    "        cols.append(i)\n",
    "\n",
    "# Разделяем на признаки и объекты\n",
    "X, y = df[cols].copy(), np.asarray(df[\"Churn\"],dtype='int8')\n",
    "\n",
    "# Инициализируем страифицированную разбивку нашего датасета для валидации\n",
    "skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "\n",
    "# Инициализируем наш классификатор с дефолтными параметрами\n",
    "rfc = RandomForestClassifier(random_state=42, n_jobs=-1, oob_score=True)\n",
    "\n",
    "# Обучаем на тренировочном датасете\n",
    "results = cross_val_score(rfc, X, y, cv=skf)\n",
    "\n",
    "# Оцениваем долю верных ответов на тестовом датасете\n",
    "print(\"CV accuracy score: {:.2f}%\".format(results.mean()*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Улучшим этот результат: посмотрим, как ведут себя кривые валидации при изменении основных параметров"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best accuracy on CV is 92.44% with 50 trees\n"
     ]
    }
   ],
   "source": [
    "# Инициализируем валидацию\n",
    "skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "\n",
    "# Создаем списки для сохранения точности на тренировочном и тестовом датасете\n",
    "train_acc = []\n",
    "test_acc = []\n",
    "temp_train_acc = []\n",
    "temp_test_acc = []\n",
    "trees_grid = [5, 10, 15, 20, 30, 50, 75, 100]\n",
    "\n",
    "# Обучаем на тренировочном датасете\n",
    "for ntrees in trees_grid:\n",
    "    rfc = RandomForestClassifier(n_estimators=ntrees, random_state=42, n_jobs=-1, oob_score=True)\n",
    "    temp_train_acc = []\n",
    "    temp_test_acc = []\n",
    "    for train_index, test_index in skf.split(X, y):\n",
    "        X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n",
    "        y_train, y_test = y[train_index], y[test_index]\n",
    "        rfc.fit(X_train, y_train)\n",
    "        temp_train_acc.append(rfc.score(X_train, y_train))\n",
    "        temp_test_acc.append(rfc.score(X_test, y_test))\n",
    "    train_acc.append(temp_train_acc)\n",
    "    test_acc.append(temp_test_acc)\n",
    "\n",
    "train_acc, test_acc = np.asarray(train_acc), np.asarray(test_acc)\n",
    "print(\"Best accuracy on CV is {:.2f}% with {} trees\".format(max(test_acc.mean(axis=1))*100, \n",
    "                                                        trees_grid[np.argmax(test_acc.mean(axis=1))]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'N_estimators')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "%matplotlib inline\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8, 4))\n",
    "ax.plot(trees_grid, train_acc.mean(axis=1), alpha=0.5, color='blue', label='train')\n",
    "ax.plot(trees_grid, test_acc.mean(axis=1), alpha=0.5, color='red', label='cv')\n",
    "ax.fill_between(trees_grid, test_acc.mean(axis=1) - test_acc.std(axis=1), test_acc.mean(axis=1) + test_acc.std(axis=1), color='#888888', alpha=0.4)\n",
    "ax.fill_between(trees_grid, test_acc.mean(axis=1) - 2*test_acc.std(axis=1), test_acc.mean(axis=1) + 2*test_acc.std(axis=1), color='#888888', alpha=0.2)\n",
    "ax.legend(loc='best')\n",
    "ax.set_ylim([0.88,1.02])\n",
    "ax.set_ylabel(\"Accuracy\")\n",
    "ax.set_xlabel(\"N_estimators\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подбираем параметр max_depth:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best accuracy on CV is 92.68% with 17 max_depth\n"
     ]
    }
   ],
   "source": [
    "# Создаем списки для сохранения точности на тренировочном и тестовом датасете\n",
    "train_acc = []\n",
    "test_acc = []\n",
    "temp_train_acc = []\n",
    "temp_test_acc = []\n",
    "max_depth_grid = [3, 5, 7, 9, 11, 13, 15, 17, 20, 22, 24]\n",
    "\n",
    "# Обучаем на тренировочном датасете\n",
    "for max_depth in max_depth_grid:\n",
    "    rfc = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1, oob_score=True, max_depth=max_depth)\n",
    "    temp_train_acc = []\n",
    "    temp_test_acc = []\n",
    "    for train_index, test_index in skf.split(X, y):\n",
    "        X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n",
    "        y_train, y_test = y[train_index], y[test_index]\n",
    "        rfc.fit(X_train, y_train)\n",
    "        temp_train_acc.append(rfc.score(X_train, y_train))\n",
    "        temp_test_acc.append(rfc.score(X_test, y_test))\n",
    "    train_acc.append(temp_train_acc)\n",
    "    test_acc.append(temp_test_acc)\n",
    "\n",
    "train_acc, test_acc = np.asarray(train_acc), np.asarray(test_acc)\n",
    "print(\"Best accuracy on CV is {:.2f}% with {} max_depth\".format(max(test_acc.mean(axis=1))*100, \n",
    "                                                        max_depth_grid[np.argmax(test_acc.mean(axis=1))]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'Max_depth')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 4))\n",
    "ax.plot(max_depth_grid, train_acc.mean(axis=1), alpha=0.5, color='blue', label='train')\n",
    "ax.plot(max_depth_grid, test_acc.mean(axis=1), alpha=0.5, color='red', label='cv')\n",
    "ax.fill_between(max_depth_grid, test_acc.mean(axis=1) - test_acc.std(axis=1), test_acc.mean(axis=1) + test_acc.std(axis=1), color='#888888', alpha=0.4)\n",
    "ax.fill_between(max_depth_grid, test_acc.mean(axis=1) - 2*test_acc.std(axis=1), test_acc.mean(axis=1) + 2*test_acc.std(axis=1), color='#888888', alpha=0.2)\n",
    "ax.legend(loc='best')\n",
    "ax.set_ylim([0.88,1.02])\n",
    "ax.set_ylabel(\"Accuracy\")\n",
    "ax.set_xlabel(\"Max_depth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Параметр max_depth хорошо справляется с регуляризацией модели, и мы уже не так сильно переобучаемся. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Параметр min_samples_leaf также выполняет функцию регуляризатора."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best accuracy on CV is 92.41% with 3 min_samples_leaf\n"
     ]
    }
   ],
   "source": [
    "# Создаем списки для сохранения точности на тренировочном и тестовом датасете\n",
    "train_acc = []\n",
    "test_acc = []\n",
    "temp_train_acc = []\n",
    "temp_test_acc = []\n",
    "min_samples_leaf_grid = [1, 3, 5, 7, 9, 11, 13, 15, 17, 20, 22, 24]\n",
    "\n",
    "# Обучаем на тренировочном датасете\n",
    "for min_samples_leaf in min_samples_leaf_grid:\n",
    "    rfc = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1, \n",
    "                                 oob_score=True, min_samples_leaf=min_samples_leaf)\n",
    "    temp_train_acc = []\n",
    "    temp_test_acc = []\n",
    "    for train_index, test_index in skf.split(X, y):\n",
    "        X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n",
    "        y_train, y_test = y[train_index], y[test_index]\n",
    "        rfc.fit(X_train, y_train)\n",
    "        temp_train_acc.append(rfc.score(X_train, y_train))\n",
    "        temp_test_acc.append(rfc.score(X_test, y_test))\n",
    "    train_acc.append(temp_train_acc)\n",
    "    test_acc.append(temp_test_acc)\n",
    "\n",
    "train_acc, test_acc = np.asarray(train_acc), np.asarray(test_acc)\n",
    "print(\"Best accuracy on CV is {:.2f}% with {} min_samples_leaf\".format(max(test_acc.mean(axis=1))*100, \n",
    "                                                        min_samples_leaf_grid[np.argmax(test_acc.mean(axis=1))]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'Min_samples_leaf')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 4))\n",
    "ax.plot(min_samples_leaf_grid, train_acc.mean(axis=1), alpha=0.5, color='blue', label='train')\n",
    "ax.plot(min_samples_leaf_grid, test_acc.mean(axis=1), alpha=0.5, color='red', label='cv')\n",
    "ax.fill_between(min_samples_leaf_grid, test_acc.mean(axis=1) - test_acc.std(axis=1), test_acc.mean(axis=1) + test_acc.std(axis=1), color='#888888', alpha=0.4)\n",
    "ax.fill_between(min_samples_leaf_grid, test_acc.mean(axis=1) - 2*test_acc.std(axis=1), test_acc.mean(axis=1) + 2*test_acc.std(axis=1), color='#888888', alpha=0.2)\n",
    "ax.legend(loc='best')\n",
    "ax.set_ylim([0.88,1.02])\n",
    "ax.set_ylabel(\"Accuracy\")\n",
    "ax.set_xlabel(\"Min_samples_leaf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотрим такой параметр как max_features. Для задач классификации по умолчанию используется $\\sqrt{n}$, где $n$ — число признаков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best accuracy on CV is 92.59% with 12 max_features\n"
     ]
    }
   ],
   "source": [
    "# Создаем списки для сохранения точности на тренировочном и тестовом датасете\n",
    "train_acc = []\n",
    "test_acc = []\n",
    "temp_train_acc = []\n",
    "temp_test_acc = []\n",
    "max_features_grid = [2, 4, 6, 8, 10, 12, 14, 16]\n",
    "\n",
    "# Обучаем на тренировочном датасете\n",
    "for max_features in max_features_grid:\n",
    "    rfc = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1, \n",
    "                                 oob_score=True, max_features=max_features)\n",
    "    temp_train_acc = []\n",
    "    temp_test_acc = []\n",
    "    for train_index, test_index in skf.split(X, y):\n",
    "        X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n",
    "        y_train, y_test = y[train_index], y[test_index]\n",
    "        rfc.fit(X_train, y_train)\n",
    "        temp_train_acc.append(rfc.score(X_train, y_train))\n",
    "        temp_test_acc.append(rfc.score(X_test, y_test))\n",
    "    train_acc.append(temp_train_acc)\n",
    "    test_acc.append(temp_test_acc)\n",
    "\n",
    "train_acc, test_acc = np.asarray(train_acc), np.asarray(test_acc)\n",
    "print(\"Best accuracy on CV is {:.2f}% with {} max_features\".format(max(test_acc.mean(axis=1))*100, \n",
    "                                                        max_features_grid[np.argmax(test_acc.mean(axis=1))]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'Max_features')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 4))\n",
    "ax.plot(max_features_grid, train_acc.mean(axis=1), alpha=0.5, color='blue', label='train')\n",
    "ax.plot(max_features_grid, test_acc.mean(axis=1), alpha=0.5, color='red', label='cv')\n",
    "ax.fill_between(max_features_grid, test_acc.mean(axis=1) - test_acc.std(axis=1), test_acc.mean(axis=1) + test_acc.std(axis=1), color='#888888', alpha=0.4)\n",
    "ax.fill_between(max_features_grid, test_acc.mean(axis=1) - 2*test_acc.std(axis=1), test_acc.mean(axis=1) + 2*test_acc.std(axis=1), color='#888888', alpha=0.2)\n",
    "ax.legend(loc='best')\n",
    "ax.set_ylim([0.88,1.02])\n",
    "ax.set_ylabel(\"Accuracy\")\n",
    "ax.set_xlabel(\"Max_features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В нашем случае оптимальное число признаков - 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, итоговый перебор параметров будет выглядеть следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 64 candidates, totalling 320 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done  42 tasks      | elapsed:   10.0s\n",
      "[Parallel(n_jobs=-1)]: Done 192 tasks      | elapsed:  1.2min\n",
      "[Parallel(n_jobs=-1)]: Done 320 out of 320 | elapsed:  2.3min finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=StratifiedKFold(n_splits=5, random_state=42, shuffle=True),\n",
       "       error_score='raise',\n",
       "       estimator=RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=-1,\n",
       "            oob_score=True, random_state=42, verbose=0, warm_start=False),\n",
       "       fit_params=None, iid=True, n_jobs=-1,\n",
       "       param_grid={'min_samples_leaf': [1, 3, 5, 7], 'max_depth': [5, 10, 15, 20], 'max_features': [4, 7, 10, 13]},\n",
       "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
       "       scoring=None, verbose=1)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Сделаем инициализацию параметров, по которым хотим сделать полный перебор\n",
    "parameters = {'max_features': [4, 7, 10, 13], 'min_samples_leaf': [1, 3, 5, 7], 'max_depth': [5,10,15,20]}\n",
    "rfc = RandomForestClassifier(n_estimators=100, random_state=42, \n",
    "                             n_jobs=-1, oob_score=True)\n",
    "gcv = GridSearchCV(rfc, parameters, n_jobs=-1, cv=skf, verbose=1)\n",
    "gcv.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Есть ли переобучение с увеличением числа деревьев?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_estimators =   10 train_acc = 0.9876265466816648 test_acc = 0.9054054054054054\n",
      "n_estimators =   40 train_acc = 0.9992500937382827 test_acc = 0.9024024024024024\n",
      "n_estimators =  100 train_acc =  1.0 test_acc = 0.9084084084084084\n",
      "n_estimators =  200 train_acc =  1.0 test_acc = 0.9054054054054054\n",
      "n_estimators =  600 train_acc =  1.0 test_acc = 0.9069069069069069\n",
      "n_estimators = 1000 train_acc =  1.0 test_acc = 0.9069069069069069\n",
      "CPU times: user 2.45 s, sys: 890 ms, total: 3.34 s\n",
      "Wall time: 20.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "for n_estimators in [10, 40, 100, 200, 600, 1000]:\n",
    "    clf = BaggingClassifier(base_estimator=DecisionTreeClassifier(), n_estimators=n_estimators, n_jobs=4)\n",
    "    clf = clf.fit(X_train, y_train)\n",
    "    train_acc, test_acc = accuracy_score(clf.predict(X_train), y_train), accuracy_score(clf.predict(X_test), y_test)\n",
    "    print('n_estimators = %4s train_acc = %4s test_acc = %4s' %(n_estimators, train_acc, test_acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_estimators =   10 train_acc = 0.9497562804649419 test_acc = 0.9129129129129129\n",
      "n_estimators =   40 train_acc = 0.9505061867266592 test_acc = 0.9144144144144144\n",
      "n_estimators =  100 train_acc = 0.9508811398575178 test_acc = 0.9159159159159159\n",
      "n_estimators =  200 train_acc = 0.9497562804649419 test_acc = 0.9129129129129129\n",
      "n_estimators =  600 train_acc = 0.9505061867266592 test_acc = 0.9129129129129129\n",
      "n_estimators = 1000 train_acc = 0.9501312335958005 test_acc = 0.9129129129129129\n",
      "CPU times: user 2.2 s, sys: 850 ms, total: 3.05 s\n",
      "Wall time: 13.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "for n_estimators in [10, 40, 100, 200, 600, 1000]:\n",
    "    clf = BaggingClassifier(base_estimator=DecisionTreeClassifier(max_depth=7), n_estimators=n_estimators, n_jobs=4)\n",
    "    clf = clf.fit(X_train, y_train)\n",
    "    train_acc, test_acc = accuracy_score(clf.predict(X_train), y_train), accuracy_score(clf.predict(X_test), y_test)\n",
    "    print('n_estimators = %4s train_acc = %4s test_acc = %4s' %(n_estimators, train_acc, test_acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_estimators =   10 train_acc = 0.9797525309336333 test_acc = 0.9069069069069069\n",
      "n_estimators =   40 train_acc = 0.9835020622422197 test_acc = 0.9054054054054054\n",
      "n_estimators =  100 train_acc = 0.9868766404199475 test_acc = 0.9099099099099099\n",
      "n_estimators =  200 train_acc = 0.9850018747656543 test_acc = 0.9069069069069069\n",
      "n_estimators =  600 train_acc = 0.9861267341582303 test_acc = 0.9069069069069069\n",
      "n_estimators = 1000 train_acc = 0.9857517810273716 test_acc = 0.9084084084084084\n",
      "CPU times: user 2.44 s, sys: 1.05 s, total: 3.49 s\n",
      "Wall time: 19.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "for n_estimators in [10, 40, 100, 200, 600, 1000]:\n",
    "    clf = BaggingClassifier(base_estimator=DecisionTreeClassifier(max_depth=14), n_estimators=n_estimators, n_jobs=4)\n",
    "    clf = clf.fit(X_train, y_train)\n",
    "    train_acc, test_acc = accuracy_score(clf.predict(X_train), y_train), accuracy_score(clf.predict(X_test), y_test)\n",
    "    print('n_estimators = %4s train_acc = %4s test_acc = %4s' %(n_estimators, train_acc, test_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Out-of-bag error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='img/oob.png' width=700>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задача** Покажите, что примерно 37% примеров остаются вне выборки бутстрэпа и не используются при построении k-го дерева."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Решение** Пусть в выборке $l$ объектов. На каждом шаге все объекты попадают в подвыборку с возвращением равновероятно, т.е отдельный объект — с вероятностью $\\dfrac{1}{l}$. Вероятность того, что объект НЕ попадет в подвыборку (т.е. его не взяли $l$ раз): $(1-\\dfrac{1}{l})^l$\n",
    "\n",
    "\n",
    "$$\\lim_{l \\rightarrow +\\infty} (1-\\dfrac{1}{l})^l = \\dfrac{1}{e}$$\n",
    "\n",
    "Тогда вероятность попадания конкретного объекта в подвыборку $1 - \\dfrac{1}{e} \\approx 63\\%$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Out-of-Bag оценка — это усредненная оценка базовых алгоритмов на тех ~37% данных, на которых они не обучались."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Отбор признаков с помощью случайного леса"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='img/features.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Как вычисляется feature importance?\n",
    "\n",
    "Каждый узел дерева использует конкретную фичу для максимизации критерия информативности. Для каждой фичи можно посчитать взвешенное (по размеру выборки) суммарное (по всем вершинам) изменение критерия информативности. \n",
    "И с помощью полученных результатов отсортировать фичи по важности.\n",
    "Для леса, данные значения можно вначале усреднить по всем деревьям, а уже затем отсортировать. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также можно напрямую измерять влияние фичи на качество модели. Например случайно переставлять значения какой-то фичи в тестовой выборке и смотреть как сильно ухудшается качество."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данные можно взять здесь: https://github.com/Yorko/mlcourse_open/blob/master/data/hostel_factors.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2020-03-15 19:45:46--  https://raw.githubusercontent.com/Yorko/mlcourse.ai/master/data/hostel_factors.csv\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.112.133\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.112.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 2873 (2.8K) [text/plain]\n",
      "Saving to: ‘hostel_factors.csv’\n",
      "\n",
      "hostel_factors.csv  100%[===================>]   2.81K  --.-KB/s    in 0s      \n",
      "\n",
      "2020-03-15 19:45:46 (11.0 MB/s) - ‘hostel_factors.csv’ saved [2873/2873]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget https://raw.githubusercontent.com/Yorko/mlcourse.ai/master/data/hostel_factors.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n",
      "Feature ranking:\n",
      "1. Персонал 0.182757 \n",
      "2. Цена/качество 0.148373 \n",
      "3. Состояние общего пространства 0.128296 \n",
      "4. Дополнительные услуги 0.116604 \n",
      "5. ССЦ 0.106668 \n",
      "6. Общие условия и удобства 0.088589 \n",
      "7. Состояние общей кухни 0.074273 \n",
      "8. Заезд в хостел и выезд из хостела 0.061521 \n",
      "9. Бронирование хостела  0.053615 \n",
      "10. Состояние комнаты 0.039305 \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f201837d908>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from __future__ import division, print_function\n",
    "# отключим всякие предупреждения Anaconda\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "%pylab inline\n",
    "import seaborn as sns\n",
    "# russian headres\n",
    "from matplotlib import rc\n",
    "font = {'family': 'Verdana',\n",
    "        'weight': 'normal'}\n",
    "rc('font', **font)\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.ensemble.forest import RandomForestRegressor\n",
    "\n",
    "hostel_data = pd.read_csv(\"hostel_factors.csv\")\n",
    "features = {\"f1\":u\"Персонал\",\n",
    "\"f2\":u\"Бронирование хостела \",\n",
    "\"f3\":u\"Заезд в хостел и выезд из хостела\",\n",
    "\"f4\":u\"Состояние комнаты\",\n",
    "\"f5\":u\"Состояние общей кухни\",\n",
    "\"f6\":u\"Состояние общего пространства\",\n",
    "\"f7\":u\"Дополнительные услуги\",\n",
    "\"f8\":u\"Общие условия и удобства\",\n",
    "\"f9\":u\"Цена/качество\",\n",
    "\"f10\":u\"ССЦ\"}\n",
    "\n",
    "forest = RandomForestRegressor(n_estimators=1000, max_features=10,\n",
    "                                random_state=0)\n",
    "\n",
    "forest.fit(hostel_data.drop(['hostel', 'rating'], axis=1), \n",
    "           hostel_data['rating'])\n",
    "importances = forest.feature_importances_\n",
    "\n",
    "indices = np.argsort(importances)[::-1]\n",
    "# Plot the feature importancies of the forest\n",
    "num_to_plot = 10\n",
    "feature_indices = [ind+1 for ind in indices[:num_to_plot]]\n",
    "\n",
    "# Print the feature ranking\n",
    "print(\"Feature ranking:\")\n",
    "\n",
    "for f in range(num_to_plot):\n",
    "    print(\"%d. %s %f \" % (f + 1, \n",
    "            features[\"f\"+str(feature_indices[f])], \n",
    "            importances[indices[f]]))\n",
    "plt.figure(figsize=(15,5))\n",
    "plt.title(u\"Важность конструктов\")\n",
    "bars = plt.bar(range(num_to_plot), \n",
    "               importances[indices[:num_to_plot]],\n",
    "       color=([str(i/float(num_to_plot+1)) \n",
    "               for i in range(num_to_plot)]),\n",
    "               align=\"center\")\n",
    "ticks = plt.xticks(range(num_to_plot), \n",
    "                   feature_indices)\n",
    "plt.xlim([-1, num_to_plot])\n",
    "plt.legend(bars, [u''.join(features[\"f\"+str(i)]) \n",
    "                  for i in feature_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Выводы</h1> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Bagging**:\n",
    "    - Одна из лучших техник для построения алгоритмов ML\n",
    "    - Линейно уменьшает разброс и не уменьшает смещение (если не коррелированы ответы базовых алоритмов) \n",
    "    - Слабое переобучение\n",
    "    - НО переобучение ЕСТЬ -- от сложности одного алгоритма, лучше все же немного обрезать деревья\n",
    "\n",
    "** Random Forest **\n",
    "\n",
    "Плюсы:\n",
    "- имеет высокую точность предсказания, на большинстве задач будет лучше линейных алгоритмов; точность сравнима с точностью бустинга\n",
    "- практически не чувствителен к выбросам в данных из-за случайного сэмлирования\n",
    "- не чувствителен к масштабированию (и вообще к любым монотонным преобразованиям) значений признаков, связано с выбором случайных подпространств\n",
    "- не требует тщательной настройки параметров, хорошо работает «из коробки». С помощью «тюнинга» параметров можно достичь прироста от 0.5 до 3% точности в зависимости от задачи и данных\n",
    "- способен эффективно обрабатывать данные с большим числом признаков и классов\n",
    "- одинаково хорошо обрабатывет как непрерывные, так и дискретные признаки\n",
    "- редко переобучается, на практике добавление деревьев почти всегда только улучшает композицию, но на валидации, после достижения определенного количества деревьев, кривая обучения выходит на асимптоту\n",
    "- для случайного леса существуют методы оценивания значимости отдельных признаков в модели\n",
    "- хорошо работает с пропущенными данными; сохраняет хорошую точность, если большая часть данных пропущенна\n",
    "- предполагает возможность сбалансировать вес каждого класса на всей выборке, либо на подвыборке каждого дерева\n",
    "- вычисляет близость между парами объектов, которые могут использоваться при кластеризации, обнаружении выбросов или (путем масштабирования) дают интересные представления данных\n",
    "- возможности, описанные выше, могут быть расширены до неразмеченных данных, что приводит к возможности делать кластеризацию и визуализацию данных, обнаруживать выбросы\n",
    "- высокая параллелизуемость и масштабируемость.\n",
    "\n",
    "Минусы:\n",
    "- в отличие от одного дерева, результаты случайного леса сложнее интерпретировать\n",
    "- нет формальных выводов (p-values), доступных для оценки важности переменных\n",
    "- алгоритм работает хуже многих линейных методов, когда в выборке очень много разреженных признаков (тексты, Bag of words)\n",
    "- случайный лес не умеет экстраполировать, в отличие от той же линейной регрессии (но это можно считать и плюсом, так как не будет экстремальных значений в случае попадания выброса)\n",
    "- алгоритм склонен к переобучению на некоторых задачах, особенно на зашумленных данных\n",
    "- для данных, включающих категориальные переменные с различным количеством уровней, случайные леса предвзяты в пользу признаков с большим количеством уровней: когда у признака много уровней, дерево будет сильнее подстраиваться именно под эти признаки, так как на них можно получить более высокое значение оптимизируемого функционала (типа прироста информации)\n",
    "- если данные содержат группы коррелированных признаков, имеющих схожую значимость для меток, то предпочтение отдается небольшим группам перед большими\n",
    "- больший размер получающихся моделей. Требуется $O(NK)$ памяти для хранения модели, где $K$ — число деревьев."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
